Mastering TypeScript Error Messages: Crafting Custom Error Types for Robust Applications

സോഫ്റ്റ്‌വെയർ വികസനത്തിന്റെ ചലനാത്മക ലോകത്ത്, പ്രതിരോധശേഷിയുള്ളതും പരിപാലിക്കാൻ എളുപ്പമുള്ളതുമായ ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കുന്നതിന് പിശകുകൾ മനോഹരമായി കൈകാര്യം ചെയ്യുന്നത് അത്യാവശ്യമാണ്. TypeScript, അതിൻ്റെ ശക്തമായ ടൈപ്പിംഗ് സിസ്റ്റം ഉപയോഗിച്ച്, കംപൈൽ സമയത്ത് സാധ്യമായ പല പ്രശ്നങ്ങളും പിടികൂടാൻ ശക്തമായ അടിത്തറ നൽകുന്നു. എന്നിരുന്നാലും, റൺടൈം പിശകുകൾ ഏതൊരു ആപ്ലിക്കേഷന്റെയും ഭാഗമാണ്. TypeScript-ൻ്റെ അന്തർനിർമ്മിതമായ പിശക് കൈകാര്യം ചെയ്യാനുള്ള സംവിധാനങ്ങൾ ശക്തമാണെങ്കിലും, കൂടുതൽ നിർദ്ദിഷ്ടവും സന്ദർഭോചിതവുമായ പിശക് മാനേജ്മെൻ്റ് നമുക്ക് ആവശ്യമായ സമയങ്ങളുണ്ട്. ഇവിടെയാണ് ഇഷ്‌ടമുള്ള പിശക് തരങ്ങളുടെ ഉപയോഗം ലോകമെമ്പാടുമുള്ള ഡെവലപ്പർമാർക്ക് ഒഴിച്ചുകൂടാനാവാത്ത ഉപകരണമായി മാറുന്നത്.

ഈ സമഗ്രമായ ഗൈഡ് TypeScript-ൽ ഇഷ്‌ടമുള്ള പിശക് തരങ്ങൾ ഉണ്ടാക്കുന്നതിൻ്റെയും ഉപയോഗിക്കുന്നതിൻ്റെയും കൈകാര്യം ചെയ്യുന്നതിൻ്റെയും സങ്കീർണതകളിലേക്ക് ആഴ്ന്നിറങ്ങുന്നു. ഭൂമിശാസ്ത്രപരമായ സ്ഥാനമോ ടീം വലുപ്പമോ പരിഗണിക്കാതെ, ഏതൊരു സ്കെയിലിലുള്ള പ്രോജക്റ്റുകൾക്കും ഉപയോഗിക്കാൻ കഴിയുന്ന ആനുകൂല്യങ്ങൾ, പ്രായോഗികമായ നടപ്പാക്കൽ തന്ത്രങ്ങൾ, പ്രവർത്തനക്ഷമമായ ഉൾക്കാഴ്ചകൾ എന്നിവ ഞങ്ങൾ പര്യവേക്ഷണം ചെയ്യും.

എന്തുകൊണ്ട് ആഗോള വികസനത്തിൽ ഇഷ്‌ടമുള്ള പിശക് തരങ്ങൾ പ്രധാനമാണ്

'എങ്ങനെ' എന്നതിലേക്ക് കടക്കുന്നതിനുമുമ്പ്, 'എന്തിന്' എന്ന് സ്ഥാപിക്കാം. ഡെവലപ്പർമാർ, പ്രത്യേകിച്ച് അന്തർദ്ദേശീയ ടീമുകളിൽ പ്രവർത്തിക്കുന്നവരോ ആഗോള ഉപയോക്തൃ അടിത്തറയ്ക്ക് സേവനം ചെയ്യുന്നവരോ എന്തിനാണ് ഇഷ്‌ടമുള്ള പിശക് തരങ്ങളിൽ സമയം നിക്ഷേപിക്കേണ്ടത്? അതിനുള്ള കാരണങ്ങൾ പലതാണ്:

• മെച്ചപ്പെടുത്തിയ വ്യക്തതയും എളുപ്പത്തിൽ വായിക്കാൻ കഴിയുന്നതും: പൊതുവായ പിശക് സന്ദേശങ്ങൾ അവ്യക്തവും സഹായമില്ലാത്തതുമാകാം. പ്രശ്നത്തിന്റെ സ്വഭാവം വ്യക്തമായി സൂചിപ്പിക്കുന്ന നിർദ്ദിഷ്ടവും വിവരണാത്മകവുമായ സന്ദേശങ്ങൾ നൽകാൻ ഇഷ്‌ടമുള്ള പിശക് തരങ്ങൾ നിങ്ങളെ അനുവദിക്കുന്നു, ഇത് ഡീബഗ്ഗിംഗ് ഗണ്യമായി വേഗത്തിലാക്കുന്നു, പ്രത്യേകിച്ചും വ്യത്യസ്ത സമയ മേഖലകളിലുള്ള ഡെവലപ്പർമാർക്ക് ആദ്യമായി പ്രശ്നം നേരിടേണ്ടി വരുമ്പോൾ.
• മെച്ചപ്പെട്ട ഡീബഗ്ഗിംഗ് കാര്യക്ഷമത: ഒരു പിശക് സംഭവിക്കുമ്പോൾ, എന്താണ് തെറ്റിയതെന്ന് കൃത്യമായി അറിയുന്നത് നിർണായകമാണ്. പിശകുകളെ തരംതിരിക്കാൻ ഇഷ്‌ടമുള്ള പിശക് തരങ്ങൾ നിങ്ങളെ പ്രാപ്തരാക്കുന്നു, ഇത് പരാജയത്തിന്റെ ഉറവിടവും സന്ദർഭവും പെട്ടെന്ന് കണ്ടെത്താൻ ഡെവലപ്പർമാരെ അനുവദിക്കുന്നു. നേരിട്ടുള്ള സഹകരണം പരിമിതമായിരിക്കാൻ സാധ്യതയുള്ള വിതരണം ചെയ്യപ്പെട്ട ടീമുകൾക്ക് ഇത് അമൂല്യമാണ്.
• തരിശായ പിശക് കൈകാര്യം ചെയ്യൽ: എല്ലാ പിശകുകളും ഒരുപോലെയല്ല ഉണ്ടാക്കുന്നത്. ചിലത് വീണ്ടെടുക്കാവുന്നതാണ്, മറ്റുള്ളവ ഗുരുതരമായ പരാജയം സൂചിപ്പിക്കുന്നു. വ്യത്യസ്ത പിശക് വിഭാഗങ്ങൾക്കായി നിർദ്ദിഷ്ട ക്യാച്ച് ബ്ലോക്കുകൾ നടപ്പിലാക്കാൻ ഇഷ്‌ടമുള്ള പിശക് തരങ്ങൾ നിങ്ങളെ അനുവദിക്കുന്നു, ഇത് കൂടുതൽ ലക്ഷ്യമിട്ടുള്ളതും ബുദ്ധിപരവുമായ പിശക് വീണ്ടെടുക്കൽ തന്ത്രങ്ങൾ പ്രാപ്തമാക്കുന്നു. ഉദാഹരണത്തിന്, ഒരു നെറ്റ്‌വർക്ക് പിശക് വീണ്ടും ശ്രമിക്കാവുന്നതാണ്, അതേസമയം ഒരു പ്രാമാണീകരണ പരാജയത്തിന് വ്യത്യസ്ത ഉപയോക്തൃ ഫ്ലോ ആവശ്യമാണ്.
• ഡൊമെയ്ൻ-നിർദ്ദിഷ്ട വിവരങ്ങൾ: നിങ്ങളുടെ ആപ്ലിക്കേഷൻ ഒരു പ്രത്യേക ഡൊമെയ്‌നിൽ പ്രവർത്തിക്കാൻ സാധ്യതയുണ്ട് (ഉദാഹരണത്തിന്, ഇ-കൊമേഴ്‌സ്, ഫിനാൻസ്, ഹെൽത്ത് കെയർ). ഇഷ്‌ടമുള്ള പിശക് തരങ്ങൾക്ക് ഡൊമെയ്ൻ-നിർദ്ദിഷ്ട ഡാറ്റ എൻക്യാപ്സുലേറ്റ് ചെയ്യാൻ കഴിയും, ഇത് കൂടുതൽ സമ്പന്നമായ സന്ദർഭം നൽകുന്നു. ഉദാഹരണത്തിന്, ഒരു പേയ്‌മെന്റ് പ്രോസസ്സിംഗ് സിസ്റ്റത്തിലെ InsufficientFundsError അഭ്യർത്ഥിച്ച തുകയെയും ലഭ്യമായ ബാലൻസിനെയും കുറിച്ചുള്ള വിശദാംശങ്ങൾ നൽകാൻ കഴിയും.
• ലളിതമായ ടെസ്റ്റിംഗ്: യൂണിറ്റ് അല്ലെങ്കിൽ ഇന്റഗ്രേഷൻ ടെസ്റ്റുകൾ എഴുതുമ്പോൾ, നന്നായി നിർവചിക്കപ്പെട്ട പിശക് തരങ്ങൾ ഉണ്ടാകുന്നത് പ്രതീക്ഷിച്ച ഫലങ്ങൾ ഉറപ്പിക്കുന്നത് എളുപ്പമാക്കുന്നു. നിങ്ങളുടെ പിശക് കൈകാര്യം ചെയ്യാനുള്ള യുക്തി ഉദ്ദേശിച്ച രീതിയിൽ പ്രവർത്തിക്കുന്നുണ്ടെന്ന് ഉറപ്പാക്കിക്കൊണ്ട് ഒരു പ്രത്യേക ഇഷ്‌ടമുള്ള പിശക് സംഭവിക്കുന്നത് നിങ്ങൾക്ക് പ്രത്യേകമായി പരീക്ഷിക്കാൻ കഴിയും.
• മികച്ച API ഡിസൈൻ: API-കൾ നൽകുന്ന ആപ്ലിക്കേഷനുകൾക്കായി, ഇഷ്‌ടമുള്ള പിശക് തരങ്ങൾ ഉപഭോക്താക്കൾക്ക് പിശകുകൾ കൈമാറാൻ ഘടനാപരമായതും പ്രവചിക്കാവുന്നതുമായ മാർഗ്ഗം നൽകുന്നു. ഇത് കൂടുതൽ കരുത്തുറ്റ സംയോജനങ്ങളിലേക്കും ലോകമെമ്പാടുമുള്ള API ഉപയോക്താക്കൾക്ക് മികച്ച ഡെവലപ്പർ അനുഭവത്തിലേക്കും നയിക്കുന്നു.
• കുറഞ്ഞ സാങ്കേതിക കടം: മുൻകൈയെടുത്തുള്ളതും നന്നായി രൂപകൽപ്പന ചെയ്തതുമായ പിശക് കൈകാര്യം ചെയ്യൽ ആശയക്കുഴപ്പമുണ്ടാക്കുന്നതും ഡീബഗ് ചെയ്യാൻ പ്രയാസമുള്ളതുമായ പ്രശ്നങ്ങളുടെ വർദ്ധനവ് തടയുന്നു, ഇത് ആത്യന്തികമായി സാങ്കേതിക കടം കുറയ്ക്കുകയും കോഡ്ബേസിന്റെ ദീർഘകാല നിലനിൽപ്പ് മെച്ചപ്പെടുത്തുകയും ചെയ്യുന്നു.

TypeScript-ൻ്റെ പിശക് കൈകാര്യം ചെയ്യാനുള്ള അടിസ്ഥാനം മനസിലാക്കുക

TypeScript JavaScript-ൻ്റെ അടിസ്ഥാന പിശക് കൈകാര്യം ചെയ്യാനുള്ള സംവിധാനങ്ങളെ പ്രയോജനപ്പെടുത്തുന്നു, പ്രധാനമായും try...catch...finally ബ്ലോക്കും Error ഒബ്ജക്റ്റും ഉപയോഗിക്കുന്നു. JavaScript-ലെ സാധാരണ Error ഒബ്ജക്റ്റിന് കുറച്ച് പ്രധാന പ്രോപ്പർട്ടികളുണ്ട്:

• message: പിശകിനെക്കുറിച്ചുള്ള മനുഷ്യന് വായിക്കാൻ കഴിയുന്ന വിവരണം.
• name: പിശക് തരത്തിൻ്റെ പേര് (ഉദാഹരണത്തിന്, 'Error', 'TypeError').
• stack: പിശക് സംഭവിച്ച സ്ഥലത്തെ കോൾ സ്റ്റാക്ക് അടങ്ങിയ ഒരു സ്ട്രിംഗ്.

നിങ്ങൾ TypeScript-ൽ ഒരു പൊതുവായ പിശക് എറിയുമ്പോൾ, അത് ഏകദേശം ഇങ്ങനെയിരിക്കും:

            
function processData(data: any) {
  if (!data || typeof data !== 'object') {
    throw new Error('Invalid data provided. Expected an object.');
  }
  // ... process data
}

try {
  processData(null);
} catch (error) {
  console.error(error.message);
}

            

              
                Copy
              
            
          

ഇത് പ്രവർത്തിക്കുമ്പോൾ, 'Invalid data provided. Expected an object.' എന്ന പിശക് സന്ദേശം വളരെ പൊതുവായതാണ്. ഒന്നിലധികം തരത്തിലുള്ള തെറ്റായ ഡാറ്റകൾ ഉണ്ടെങ്കിലോ? ഒരു പാരാമീറ്റർ കാണാനില്ലാത്തതും തെറ്റായ രീതിയിലുള്ള പാരാമീറ്ററും തമ്മിൽ വേർതിരിച്ചറിയാൻ നമ്മുക്ക് ആവശ്യമുണ്ടെങ്കിലോ?

നിങ്ങളുടെ ആദ്യത്തെ ഇഷ്‌ടമുള്ള പിശക് തരം നടപ്പിലാക്കുക

TypeScript-ൽ ഇഷ്‌ടമുള്ള പിശക് തരങ്ങൾ ഉണ്ടാക്കുന്നതിനുള്ള ഏറ്റവും സാധാരണമായതും ഫലപ്രദവുമായ മാർഗ്ഗം, അന്തർനിർമ്മിതമായ Error ക്ലാസ് വികസിപ്പിക്കുക എന്നതാണ്. ഇത് നിങ്ങളുടെ ഇഷ്‌ടമുള്ള പിശകിനെ ഒരു സാധാരണ പിശക് ഒബ്ജക്റ്റിൻ്റെ എല്ലാ പ്രോപ്പർട്ടികളും സ്വീകരിക്കാൻ അനുവദിക്കുകയും നിങ്ങളുടെ സ്വന്തം നിർദ്ദിഷ്ട പ്രോപ്പർട്ടികളും രീതികളും ചേർക്കാൻ നിങ്ങളെ പ്രാപ്തരാക്കുകയും ചെയ്യുന്നു.

അടിസ്ഥാന ഇഷ്‌ടമുള്ള പിശക് ക്ലാസ്

ഡാറ്റാ മൂല്യനിർണ്ണയത്തിലെ പ്രശ്‌നങ്ങളെ പ്രതിനിധീകരിക്കുന്ന ലളിതമായ ഇഷ്‌ടമുള്ള പിശകായ ValidationError-ൽ നിന്ന് നമുക്ക് ആരംഭിക്കാം.

            
class ValidationError extends Error {
  constructor(message: string) {
    super(message); // Call the parent constructor (Error)
    this.name = 'ValidationError'; // Set the name of the error

    // Maintains proper stack trace for where our error was thrown (only available on V8)
    if (Error.captureStackTrace) {
      Error.captureStackTrace(this, ValidationError);
    }
  }
}

            

              
                Copy
              
            
          

വിശദീകരണം:

• നമ്മൾ Error വികസിപ്പിക്കുന്ന ValidationError എന്ന ക്ലാസ് നിർവചിക്കുന്നു.
• constructor ഒരു message സ്ട്രിംഗ് എടുക്കുന്നു, അത് super() കോളിലേക്ക് കൈമാറ്റം ചെയ്യപ്പെടുന്നു. ഇത് സന്ദേശം ഉപയോഗിച്ച് അടിസ്ഥാന Error ക്ലാസ് ആരംഭിക്കുന്നു.
• this.name = 'ValidationError' എന്ന് നമ്മൾ വ്യക്തമായി സജ്ജമാക്കുന്നു. സ്ഥിരസ്ഥിതി 'Error' നാമം മറികടന്ന് നമ്മുടെ ഇഷ്‌ടമുള്ള പിശക് തരം വ്യക്തമായി തിരിച്ചറിയുന്നതിനാൽ ഇത് നല്ല പരിശീലനമാണ്.
• Error.captureStackTrace(this, ValidationError) എന്ന വരി ഒരു V8-നിർദ്ദിഷ്ട ഒപ്റ്റിമൈസേഷനാണ് (Node.js പരിതസ്ഥിതികളിൽ സാധാരണമാണ്), ഇത് സ്റ്റാക്കിൽ നിന്ന് കൺസ്ട്രക്റ്റർ കോൾ ഒഴിവാക്കി ശരിയായ സ്റ്റാക്ക് ട്രെയ്സ് നേടാൻ സഹായിക്കുന്നു. ഇത് നിർബന്ധമല്ല, പക്ഷേ മികച്ച ഡീബഗ്ഗിംഗിനായി ശുപാർശ ചെയ്യുന്നു.

ഇഷ്‌ടമുള്ള പിശകുകൾ എറിയുകയും പിടിക്കുകയും ചെയ്യുക

ഇനി, ഈ ValidationError എങ്ങനെ എറിയാമെന്നും പിടിക്കാമെന്നും നോക്കാം.

            
function validateEmail(email: string): void {
  if (!email || !email.includes('@')) {
    throw new ValidationError('Invalid email format. Email must contain an "@" symbol.');
  }
  console.log('Email is valid.');
}

try {
  validateEmail('test@example.com');
  validateEmail('invalid-email');
} catch (error) {
  if (error instanceof ValidationError) {
    console.error(`Validation Error: ${error.message}`);
    // You can perform specific actions for validation errors here
  } else {
    // Handle other unexpected errors
    console.error(`An unexpected error occurred: ${error.message}`);
  }
}

            

              
                Copy
              
            
          

catch ബ്ലോക്കിൽ, നമ്മുടെ ഇഷ്‌ടമുള്ള പിശക് പ്രത്യേകമായി തിരിച്ചറിയാനും കൈകാര്യം ചെയ്യാനും നമ്മൾ instanceof ValidationError ഉപയോഗിക്കുന്നു. ഇത് വ്യത്യസ്തമായ പിശക് കൈകാര്യം ചെയ്യാനുള്ള യുക്തിയെ അനുവദിക്കുന്നു.

ഇഷ്‌ടമുള്ള പിശകുകളിലേക്ക് ഡൊമെയ്ൻ-നിർദ്ദിഷ്ട പ്രോപ്പർട്ടികൾ ചേർക്കുന്നു

സന്ദർഭോചിതമായ വിവരങ്ങൾ വഹിക്കാനുള്ള കഴിവാണ് ഇഷ്‌ടമുള്ള പിശക് തരങ്ങളുടെ യഥാർത്ഥ ശക്തി. InsufficientStockError പോലുള്ള സാങ്കൽപ്പിക ഇ-കൊമേഴ്‌സ് ആപ്ലിക്കേഷനായി കൂടുതൽ സങ്കീർണ്ണമായ ഒരു പിശക് നമുക്ക് ഉണ്ടാക്കാം.

            
interface Product {
  id: string;
  name: string;
  stock: number;
}

class InsufficientStockError extends Error {
  public readonly productId: string;
  public readonly requestedQuantity: number;
  public readonly availableStock: number;

  constructor(product: Product, requestedQuantity: number) {
    const message = `Insufficient stock for product "${product.name}" (ID: ${product.id}). Requested: ${requestedQuantity}, Available: ${product.stock}.`;
    super(message);
    this.name = 'InsufficientStockError';

    this.productId = product.id;
    this.requestedQuantity = requestedQuantity;
    this.availableStock = product.stock;

    if (Error.captureStackTrace) {
      Error.captureStackTrace(this, InsufficientStockError);
    }
  }
}

// --- Usage Example ---

const productInStock: Product = {
  id: 'p123',
  name: 'Wireless Mouse',
  stock: 5
};

function placeOrder(product: Product, quantity: number): void {
  if (quantity > product.stock) {
    throw new InsufficientStockError(product, quantity);
  }
  console.log(`Order placed successfully for ${quantity} of ${product.name}.`);
  // ... update stock, process payment etc.
}

try {
  placeOrder(productInStock, 3);
  placeOrder(productInStock, 7); // This will throw InsufficientStockError
} catch (error) {
  if (error instanceof InsufficientStockError) {
    console.error(`Order failed: ${error.message}`);
    console.error(`Details - Product ID: ${error.productId}, Requested: ${error.requestedQuantity}, Available: ${error.availableStock}`);
    // Possible actions: Suggest alternative products, notify user, log for inventory management.
  } else {
    console.error(`An unexpected error occurred during order placement: ${error.message}`);
  }
}

            

              
                Copy
              
            
          

ഈ ഉദാഹരണത്തിൽ:

• InsufficientStockError-ന് കൂടുതൽ പ്രോപ്പർട്ടികളുണ്ട്: productId, requestedQuantity, കൂടാതെ availableStock.
• ഈ പ്രോപ്പർട്ടികൾ കൺസ്ട്രക്റ്ററിൽ ആരംഭിക്കുകയും പിശകിനൊപ്പം കൈമാറ്റം ചെയ്യപ്പെടുകയും ചെയ്യുന്നു.
• പിശക് പിടിക്കുമ്പോൾ, കൂടുതൽ വിശദമായ ഫീഡ്‌ബാക്ക് നൽകാനോ പ്രത്യേക വീണ്ടെടുക്കൽ ലോജിക് ട്രിഗർ ചെയ്യാനോ ഈ പ്രോപ്പർട്ടികൾ ആക്‌സസ് ചെയ്യാൻ കഴിയും. ഒരു ആഗോള പ്രേക്ഷകർക്ക്, വ്യത്യസ്ത പ്രദേശങ്ങളിലെ പ്രശ്നങ്ങൾ കാര്യക്ഷമമായി മനസ്സിലാക്കാനും പരിഹരിക്കാനും ഈ ഗ്രാനുലാർ വിവരങ്ങൾ പിന്തുണാ ടീമുകൾക്കോ ​​ഓട്ടോമേറ്റഡ് സിസ്റ്റങ്ങൾക്കോ ​​അത്യാവശ്യമാണ്.

നിങ്ങളുടെ ഇഷ്‌ടമുള്ള പിശക് ശ്രേണി ക്രമീകരിക്കുന്നു

വലിയ ആപ്ലിക്കേഷനുകൾക്കായി, ഇഷ്‌ടമുള്ള പിശകുകളുടെ ഒരു ശ്രേണി ഉണ്ടാക്കുന്നത് നിങ്ങൾക്ക് പ്രയോജനകരമാണെന്ന് കണ്ടെത്താനാകും. ഇത് കൂടുതൽ ചിട്ടയായതും ലേയേർഡ്തുമായ പിശക് കൈകാര്യം ചെയ്യലിനെ അനുവദിക്കുന്നു.

നിങ്ങൾക്ക് API-യുമായി ബന്ധപ്പെട്ട വിവിധ തരത്തിലുള്ള പിശകുകൾ ഉള്ള ഒരു സാഹചര്യം പരിഗണിക്കുക:

            
// Base API Error
class ApiError extends Error {
  constructor(message: string) {
    super(message);
    this.name = 'ApiError';
    if (Error.captureStackTrace) {
      Error.captureStackTrace(this, ApiError);
    }
  }
}

// Specific API Errors inheriting from ApiError
class NetworkError extends ApiError {
  public readonly statusCode?: number;

  constructor(message: string, statusCode?: number) {
    super(message);
    this.name = 'NetworkError';
    this.statusCode = statusCode;
    if (Error.captureStackTrace) {
      Error.captureStackTrace(this, NetworkError);
    }
  }
}

class AuthenticationError extends ApiError {
  constructor(message: string = 'Authentication failed. Please check your credentials.') {
    super(message);
    this.name = 'AuthenticationError';
    if (Error.captureStackTrace) {
      Error.captureStackTrace(this, AuthenticationError);
    }
  }
}

class ResourceNotFoundError extends ApiError {
  public readonly resourceId: string;

  constructor(resourceId: string, message: string = `Resource with ID "${resourceId}" not found.`) {
    super(message);
    this.name = 'ResourceNotFoundError';
    this.resourceId = resourceId;
    if (Error.captureStackTrace) {
      Error.captureStackTrace(this, ResourceNotFoundError);
    }
  }
}

// --- Usage Example ---

async function fetchUserData(userId: string): Promise<any> {
  const response = await fetch(`/api/users/${userId}`);

  if (!response.ok) {
    if (response.status === 401) {
      throw new AuthenticationError();
    } else if (response.status === 404) {
      throw new ResourceNotFoundError(userId);
    } else {
      throw new NetworkError(`API request failed with status ${response.status}`, response.status);
    }
  }
  return response.json();
}

try {
  const user = await fetchUserData('user123');
  console.log('User data:', user);
} catch (error) {
  if (error instanceof AuthenticationError) {
    console.error('Authentication Error:', error.message);
    // Redirect to login page globally.
  } else if (error instanceof ResourceNotFoundError) {
    console.error('Resource Not Found:', error.message);
    // Inform user that the requested resource is unavailable.
  } else if (error instanceof NetworkError) {
    console.error(`Network Error: ${error.message} (Status: ${error.statusCode})`);
    // Potentially retry the request or inform the user about connection issues.
  } else {
    console.error('An unknown API error occurred:', error.message);
  }
}

            

              
                Copy
              
            
          

ഈ ശ്രേണിപരമായ ഘടനയിൽ:

• ApiError എല്ലാ API-യുമായി ബന്ധപ്പെട്ട പ്രശ്നങ്ങൾക്കും ഒരു പൊതു അടിത്തറയായി വർത്തിക്കുന്നു.
• NetworkError, AuthenticationError, കൂടാതെ ResourceNotFoundError എന്നിവ ApiError-ൽ നിന്ന് സ്വീകരിക്കുന്നു, ഇത് ഓരോ തരത്തിനും പ്രത്യേകമായി കൈകാര്യം ചെയ്യാൻ അനുവദിക്കുന്നു.
• ഒരു ക്യാച്ച് ബ്ലോക്കിന് ആദ്യം ഏറ്റവും നിർദ്ദിഷ്ടമായ പിശകുകൾക്കായി പരിശോധിക്കാൻ കഴിയും (ഉദാഹരണത്തിന്, AuthenticationError) തുടർന്ന് ആവശ്യമെങ്കിൽ കൂടുതൽ പൊതുവായവയിലേക്ക് (ഉദാഹരണത്തിന്, ApiError) മടങ്ങിവരാം. വ്യത്യസ്ത പ്രദേശങ്ങൾക്ക് വ്യത്യസ്ത നെറ്റ്‌വർക്ക് സ്ഥിരതയോ പ്രാമാണീകരണത്തെ ബാധിക്കുന്ന നിയന്ത്രണ ആവശ്യകതകളോ ഉള്ള അന്തർദ്ദേശീയ ആപ്ലിക്കേഷനുകൾക്ക് ഇത് നിർണായകമാണ്.

ഇഷ്‌ടമുള്ള പിശക് തരങ്ങൾ നടപ്പിലാക്കുന്നതിനുള്ള മികച്ച രീതികൾ

ഇഷ്‌ടമുള്ള പിശക് തരങ്ങളുടെ ആനുകൂല്യങ്ങൾ വർദ്ധിപ്പിക്കുന്നതിന്, ഈ മികച്ച രീതികൾ പരിഗണിക്കുക:

1. നിർദ്ദിഷ്ടമായിരിക്കുക: നിങ്ങളുടെ പിശക് ക്ലാസുകൾ വ്യക്തമായും വിവരണാത്മകമായും നാമകരണം ചെയ്യുക. പേര് തന്നെ പിശകിൻ്റെ സ്വഭാവം അറിയിക്കണം.
2. Error-ൽ നിന്ന് സ്വീകരിക്കുക: നിങ്ങളുടെ ഇഷ്‌ടമുള്ള പിശകുകൾ സാധാരണ JavaScript പിശകുകൾ പോലെ പ്രവർത്തിക്കുന്നുവെന്നും message, stack പോലുള്ള ആവശ്യമായ പ്രോപ്പർട്ടികൾ ഉണ്ടെന്നും ഉറപ്പാക്കാൻ എല്ലായ്പ്പോഴും അന്തർനിർമ്മിതമായ Error ക്ലാസ് വികസിപ്പിക്കുക.
3. name പ്രോപ്പർട്ടി സജ്ജമാക്കുക: this.name നിങ്ങളുടെ ഇഷ്‌ടമുള്ള പിശക് ക്ലാസ് നാമത്തിലേക്ക് വ്യക്തമായി സജ്ജമാക്കുക. റൺടൈമിൽ തിരിച്ചറിയുന്നതിന് ഇത് അത്യാവശ്യമാണ്.
4. പ്രസക്തമായ ഡാറ്റ ഉൾപ്പെടുത്തുക: സന്ദർഭം നൽകുകയും ഡീബഗ്ഗിംഗോ വീണ്ടെടുക്കലോ സുഗമമാക്കുകയും ചെയ്യുന്ന പ്രോപ്പർട്ടികൾ നിങ്ങളുടെ ഇഷ്‌ടമുള്ള പിശകുകളിൽ ചേർക്കുക. ഒരു പ്രശ്നം മനസ്സിലാക്കാനും പരിഹരിക്കാനും ഒരു ഡെവലപ്പർക്കോ ഓട്ടോമേറ്റഡ് സിസ്റ്റത്തിനോ എന്ത് വിവരമാണ് ആവശ്യമെന്ന് ചിന്തിക്കുക.
5. നിങ്ങളുടെ പിശകുകൾ രേഖപ്പെടുത്തുക: നിങ്ങളുടെ കോഡിനെപ്പോലെ, നിങ്ങളുടെ ഇഷ്‌ടമുള്ള പിശക് തരങ്ങളും രേഖപ്പെടുത്തണം. ഓരോ പിശകും എന്താണ് അർത്ഥമാക്കുന്നതെന്നും, എന്ത് പ്രോപ്പർട്ടികളാണ് ഉള്ളതെന്നും, എപ്പോഴാണ് അത് സംഭവിക്കാൻ സാധ്യതയുള്ളതെന്നും വിശദീകരിക്കുക. ലോകമെമ്പാടും വ്യാപിച്ചുകിടക്കുന്ന ടീമുകൾക്ക് ഇത് വളരെ പ്രധാനമാണ്.
6. സ്ഥിരമായ എറിയലും പിടിക്കലും: പിശകുകൾ എങ്ങനെ, എവിടെ എറിയണം, എങ്ങനെ അവ പിടിക്കുകയും കൈകാര്യം ചെയ്യുകയും വേണം എന്നതിനെക്കുറിച്ച് നിങ്ങളുടെ ടീമിനുള്ളിൽ കൺവെൻഷനുകൾ സ്ഥാപിക്കുക. വിതരണം ചെയ്ത പരിതസ്ഥിതിയിൽ പിശക് മാനേജ്മെൻ്റിനായുള്ള ഏകീകൃത സമീപനത്തിന് ഈ സ്ഥിരത പ്രധാനമാണ്.
7. അമിത ഉപയോഗം ഒഴിവാക്കുക: ഇഷ്‌ടമുള്ള പിശകുകൾ ശക്തമാണെങ്കിലും, എല്ലാ ചെറിയ അസൗകര്യങ്ങൾക്കും ഒരെണ്ണം ഉണ്ടാക്കരുത്. പ്രത്യേക കൈകാര്യം ചെയ്യൽ ആവശ്യമുള്ള അല്ലെങ്കിൽ പ്രധാനപ്പെട്ട സന്ദർഭോചിതമായ വിവരങ്ങൾ നൽകുന്ന വ്യതിരിക്തമായ പിശക് സാഹചര്യങ്ങൾക്കായി അവ ഉപയോഗിക്കുക.
8. പിശക് കോഡുകൾ പരിഗണിക്കുക: വ്യത്യസ്ത ഭാഷകളിലോ പ്ലാറ്റ്‌ഫോമുകളിലോ പ്രോഗ്രമാറ്റിക്കായി പിശക് തിരിച്ചറിയേണ്ട സിസ്റ്റങ്ങൾക്കായി, നിങ്ങളുടെ ഇഷ്‌ടമുള്ള പിശക് തരങ്ങളിലേക്ക് ഒരു സംഖ്യാ അല്ലെങ്കിൽ സ്ട്രിംഗ് പിശക് കോഡ് ചേർക്കുന്നത് പരിഗണിക്കുക. ഇത് പ്രാദേശികവൽക്കരണത്തിനോ നിർദ്ദിഷ്ട പിന്തുണാ ലേഖനങ്ങളിലേക്ക് പിശകുകൾ മാപ്പ് ചെയ്യുന്നതിനോ ഉപയോഗപ്രദമാകും.
9. കേന്ദ്രീകൃത പിശക് കൈകാര്യം ചെയ്യൽ: വലിയ ആപ്ലിക്കേഷനുകളിൽ, ആപ്ലിക്കേഷന്റെ വിവിധ ഭാഗങ്ങളിലുടനീളം സ്ഥിരമായ ലോഗിംഗ്, റിപ്പോർട്ടിംഗ്, കൂടാതെ ഉപയോക്തൃ ഫീഡ്‌ബാക്ക് മെക്കാനിസങ്ങൾ ഉറപ്പാക്കിക്കൊണ്ട് പിശകുകൾ തടസ്സപ്പെടുത്തുകയും പ്രോസസ്സ് ചെയ്യുകയും ചെയ്യുന്ന ഒരു കേന്ദ്രീകൃത പിശക് കൈകാര്യം ചെയ്യൽ മൊഡ്യൂൾ അല്ലെങ്കിൽ സേവനം പരിഗണിക്കുക. ആഗോള ആപ്ലിക്കേഷനുകൾക്കുള്ള ഒരു നിർണായക പാറ്റേണാണിത്.

ആഗോള പരിഗണനകളും പ്രാദേശികവൽക്കരണവും

ഒരു ആഗോള പ്രേക്ഷകർക്കായി വികസിപ്പിക്കുമ്പോൾ, പിശക് സന്ദേശങ്ങൾ തന്നെ (message പ്രോപ്പർട്ടി) ശ്രദ്ധാപൂർവ്വം പരിഗണിക്കേണ്ടതുണ്ട്:

• പിശക് സന്ദേശ സ്ട്രിംഗിൽ നേരിട്ട് പ്രാദേശികവൽക്കരണം ഒഴിവാക്കുക: നിങ്ങളുടെ പിശക് ക്ലാസ്സിൽ പ്രാദേശികവൽക്കരിച്ച സന്ദേശങ്ങൾ ഹാർഡ്‌കോഡ് ചെയ്യുന്നതിനുപകരം, ഉപയോക്തൃ ലൊക്കേൽ അല്ലെങ്കിൽ ആപ്ലിക്കേഷൻ ക്രമീകരണങ്ങളെ അടിസ്ഥാനമാക്കി പ്രാദേശികവൽക്കരിച്ച സന്ദേശങ്ങൾ വീണ്ടെടുക്കാൻ നിങ്ങളുടെ സിസ്റ്റം രൂപകൽപ്പന ചെയ്യുക. നിങ്ങളുടെ ഇഷ്‌ടമുള്ള പിശക് ഒരു errorCode അല്ലെങ്കിൽ key വഹിച്ചേക്കാം, അത് ഒരു പ്രാദേശികവൽക്കരണ സേവനത്തിന് ഉപയോഗിക്കാൻ കഴിയും.
• ഡെവലപ്പർ അഭിമുഖീകരിക്കുന്ന സന്ദേശങ്ങളിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കുക: പിശക് ഒബ്‌ജക്‌റ്റിനുള്ളിലെ വിശദമായ പിശക് സന്ദേശത്തിന്റെ പ്രാഥമിക പ്രേക്ഷകർ സാധാരണയായി ഡെവലപ്പറാണ്. അതിനാൽ, ഈ സന്ദേശങ്ങൾ വ്യക്തവും സംക്ഷിപ്തവും സാങ്കേതികമായി കൃത്യവുമാണെന്ന് ഉറപ്പാക്കുക. ഉപയോക്താക്കൾക്ക് കാണാൻ കഴിയുന്ന പിശക് സന്ദേശങ്ങൾ പ്രത്യേകം കൈകാര്യം ചെയ്യുകയും ഉപയോക്തൃ-സൗഹൃദവും പ്രാദേശികവൽക്കരിച്ചതുമായിരിക്കണം.
• അന്താരാഷ്ട്ര സ്വഭാവ സെറ്റുകൾ: നിങ്ങളുടെ ഇഷ്‌ടമുള്ള പിശകുകളിലെ ഏതെങ്കിലും സ്ട്രിംഗ് പ്രോപ്പർട്ടികൾക്ക് അന്താരാഷ്ട്ര സ്വഭാവ സെറ്റുകൾ ശരിയായി കൈകാര്യം ചെയ്യാൻ കഴിയുമെന്ന് ഉറപ്പാക്കുക. TypeScript-ഉം JavaScript-ൻ്റെ സാധാരണ സ്ട്രിംഗ് കൈകാര്യം ചെയ്യലും Unicode-നെ നന്നായി പിന്തുണയ്ക്കുന്നു.

ഉദാഹരണത്തിന്, ഒരു ഇഷ്‌ടമുള്ള പിശക് ഇങ്ങനെയായിരിക്കാം:

            
class UserNotFoundError extends Error {
  public readonly userId: string;
  public readonly errorCode: string = 'ERR_USER_NOT_FOUND'; // For localization/lookup

  constructor(userId: string, message: string = 'User not found.') {
    super(message); // Default message, can be overridden or looked up.
    this.name = 'UserNotFoundError';
    this.userId = userId;
    if (Error.captureStackTrace) {
      Error.captureStackTrace(this, UserNotFoundError);
    }
  }
}

// In a localization service:
function getLocalizedErrorMessage(error: Error & { errorCode?: string }, locale: string): string {
  if (!error.errorCode) {
    return error.message;
  }

  const messages: { [key: string]: { [key: string]: string } } = {
    'en-US': {
      'ERR_USER_NOT_FOUND': `User with ID ${ (error as any).userId } could not be found.`
    },
    'es-ES': {
      'ERR_USER_NOT_FOUND': `No se encontró al usuario con ID ${ (error as any).userId }.`
    }
    // ... other locales
  };

  return messages[locale]?.[error.errorCode] || error.message;
}

// Usage:
try {
  // ... attempt to find user
  throw new UserNotFoundError('abc-123');
} catch (error) {
  if (error instanceof UserNotFoundError) {
    const userMessage = getLocalizedErrorMessage(error, 'es-ES');
    console.error(`Error: ${userMessage}`); // Displays Spanish message
  } else {
    console.error(`Generic error: ${error.message}`);
  }
}

            

              
                Copy
              
            
          

ഉപസംഹാരം

TypeScript-ൽ ഇഷ്‌ടമുള്ള പിശക് തരങ്ങൾ നടപ്പിലാക്കുന്നത് നല്ല കോഡിംഗ് പരിശീലനത്തിന്റെ കാര്യം മാത്രമല്ല; ആഗോള സന്ദർഭത്തിൽ നിങ്ങളുടെ ആപ്ലിക്കേഷനുകളുടെ കരുത്ത്, പരിപാലിക്കാനുള്ള എളുപ്പം, ഡെവലപ്പർ അനുഭവം എന്നിവ ഗണ്യമായി വർദ്ധിപ്പിക്കുന്ന ഒരു തന്ത്രപരമായ തീരുമാനമാണിത്. Error ക്ലാസ് വികസിപ്പിക്കുന്നതിലൂടെ, ഡീബഗ്ഗിംഗ് ലളിതമാക്കുകയും പിശക് കൈകാര്യം ചെയ്യുന്നതിൽ ഗ്രാനുലാർ നിയന്ത്രണം പ്രാപ്തമാക്കുകയും വിലപ്പെട്ട ഡൊമെയ്ൻ-നിർദ്ദിഷ്ട സന്ദർഭം നൽകുകയും ചെയ്യുന്ന നിർദ്ദിഷ്ടവും വിവരദായകവും പ്രവർത്തനക്ഷമവുമായ പിശക് ഒബ്ജക്റ്റുകൾ നിങ്ങൾക്ക് ഉണ്ടാക്കാൻ കഴിയും.

വൈവിധ്യമാർന്ന ഒരു അന്താരാഷ്ട്ര പ്രേക്ഷകരെ സേവിക്കുന്ന സങ്കീർണ്ണമായ ആപ്ലിക്കേഷനുകൾ നിങ്ങൾ നിർമ്മിക്കുന്നത് തുടരുമ്പോൾ, നന്നായി നിർവചിക്കപ്പെട്ട ഇഷ്‌ടമുള്ള പിശക് തന്ത്രത്തിൽ നിക്ഷേപം നടത്തുന്നത് കൂടുതൽ നേട്ടങ്ങൾ നൽകും. ഇത് വികസന ടീമുകൾക്കുള്ളിൽ വ്യക്തമായ ആശയവിനിമയത്തിലേക്ക് നയിക്കുന്നു, കൂടുതൽ കാര്യക്ഷമമായ പ്രശ്ന പരിഹാരം, ആത്യന്തികമായി ലോകമെമ്പാടുമുള്ള ഉപയോക്താക്കൾക്ക് കൂടുതൽ വിശ്വസനീയമായ സോഫ്റ്റ്‌വെയർ എന്നിവയ്ക്ക് ഇത് സഹായകമാവുന്നു. ഇഷ്‌ടമുള്ള പിശകുകളുടെ ശക്തി സ്വീകരിക്കുകയും നിങ്ങളുടെ TypeScript വികസനം അടുത്ത ഘട്ടത്തിലേക്ക് ഉയർത്തുകയും ചെയ്യുക.